#ifndef _TLVPAKCKET_H
#define _TLVPAKCKET_H

#include <vector>
#include <cstdint>
#include <cstring>
#include <string>
#include <stdexcept>

class TLVPacket {
public:
    // 构造函数
    TLVPacket(uint32_t type = 0, const std::string& value = "")
        : type(type), value(value) {
        len = static_cast<uint32_t>(value.size());
    }
    
    // 序列化为字节向量
    std::vector<uint8_t> serialize() const {
        // 计算总大小
        size_t total_size = sizeof(type) + sizeof(len) + len;
        std::vector<uint8_t> buffer(total_size);
        uint8_t* ptr = buffer.data();
        
        // 直接复制 type 的字节表示
        memcpy(ptr, &type, sizeof(type));
        ptr += sizeof(type);
        
        // 直接复制 len 的字节表示
        memcpy(ptr, &len, sizeof(len));
        ptr += sizeof(len);
        
        // 复制 value 数据
        if (len > 0) {
            memcpy(ptr, value.data(), len);
        }
        
        return buffer;
    }
    
    // 从字节向量反序列化
    static TLVPacket deserialize(const std::vector<uint8_t>& data) {
        if (data.size() < sizeof(uint32_t) * 2) {
            throw std::runtime_error("Invalid TLV data size");
        }
        
        const uint8_t* ptr = data.data();
        
        // 直接复制 type 的字节表示
        uint32_t type;
        memcpy(&type, ptr, sizeof(type));
        ptr += sizeof(type);
        
        // 直接复制 len 的字节表示
        uint32_t len;
        memcpy(&len, ptr, sizeof(len));
        ptr += sizeof(len);
        
        // 验证数据大小
        if (data.size() < sizeof(uint32_t) * 2 + len) {
            throw std::runtime_error("TLV value size exceeds data size");
        }
        
        // 复制 value 数据
        std::string value;
        if (len > 0) {
            value.assign(reinterpret_cast<const char*>(ptr), len);
        }
        
        return TLVPacket(type, value);
    }
    
    // 从字节指针反序列化
    static TLVPacket deserialize(const uint8_t* data, size_t size) {
        if (size < sizeof(uint32_t) * 2) {
            throw std::runtime_error("Invalid TLV data size");
        }
        
        const uint8_t* ptr = data;
        
        // 直接复制 type 的字节表示
        uint32_t type;
        memcpy(&type, ptr, sizeof(type));
        ptr += sizeof(type);
        
        // 直接复制 len 的字节表示
        uint32_t len;
        memcpy(&len, ptr, sizeof(len));
        ptr += sizeof(len);
        
        // 验证数据大小
        if (size < sizeof(uint32_t) * 2 + len) {
            throw std::runtime_error("TLV value size exceeds data size");
        }
        
        // 复制 value 数据
        std::string value;
        if (len > 0) {
            value.assign(reinterpret_cast<const char*>(ptr), len);
        }
        
        return TLVPacket(type, value);
    }
    
    // Getters
    uint32_t getType() const { return type; }
    uint32_t getLength() const { return len; }
    const std::string& getValue() const { return value; }
    
    // Setters
    void setType(uint32_t newType) { type = newType; }
    void setValue(const std::string& newValue) {
        value = newValue;
        len = static_cast<uint32_t>(value.size());
    }

private:
    uint32_t type;    // 数据类型
    uint32_t len;      // 数据长度
    std::string value; // 数据值
};




#endif
